{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c7035945",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 句子数量： 5\n",
      " 中文词汇表大小： 18\n",
      " 英文词汇表大小： 20\n",
      " 中文词汇到索引的字典： {'咖哥': 0, '人工智能': 1, '改变': 2, '神经网络': 3, '很': 4, '语言': 5, '复杂': 6, '学习': 7, '非常': 8, '自然': 9, '处理': 10, '深度学习': 11, '世界': 12, '强大': 13, '我': 14, '喜欢': 15, '小冰': 16, '爱': 17}\n",
      " 英文词汇到索引的字典： {'complex': 0, 'AI': 1, 'world': 2, 'I': 3, 'NLP': 4, 'the': 5, 'are': 6, '<sos>': 7, 'so': 8, 'studying': 9, 'XiaoBing': 10, 'Neural-Nets': 11, '<eos>': 12, 'powerful': 13, 'changed': 14, 'likes': 15, 'KaGe': 16, 'DL': 17, 'is': 18, 'love': 19}\n"
     ]
    }
   ],
   "source": [
    "# 构建语料库，每行包含中文、英文（解码器输入）和翻译成英文后的目标输出 3 个句子\n",
    "sentences = [\n",
    "    ['咖哥 喜欢 小冰', '<sos> KaGe likes XiaoBing', 'KaGe likes XiaoBing <eos>'],\n",
    "    ['我 爱 学习 人工智能', '<sos> I love studying AI', 'I love studying AI <eos>'],\n",
    "    ['深度学习 改变 世界', '<sos> DL changed the world', 'DL changed the world <eos>'],\n",
    "    ['自然 语言 处理 很 强大', '<sos> NLP is so powerful', 'NLP is so powerful <eos>'],\n",
    "    ['神经网络 非常 复杂', '<sos> Neural-Nets are complex', 'Neural-Nets are complex <eos>']]\n",
    "word_list_cn, word_list_en = [], []  # 初始化中英文词汇表\n",
    "# 遍历每一个句子并将单词添加到词汇表中\n",
    "for s in sentences:\n",
    "    word_list_cn.extend(s[0].split())\n",
    "    word_list_en.extend(s[1].split())\n",
    "    word_list_en.extend(s[2].split())\n",
    "# 去重，得到没有重复单词的词汇表\n",
    "word_list_cn = list(set(word_list_cn))\n",
    "word_list_en = list(set(word_list_en))\n",
    "# 构建单词到索引的映射\n",
    "word2idx_cn = {w: i for i, w in enumerate(word_list_cn)}\n",
    "word2idx_en = {w: i for i, w in enumerate(word_list_en)}\n",
    "# 构建索引到单词的映射\n",
    "idx2word_cn = {i: w for i, w in enumerate(word_list_cn)}\n",
    "idx2word_en = {i: w for i, w in enumerate(word_list_en)}\n",
    "# 计算词汇表的大小\n",
    "voc_size_cn = len(word_list_cn)\n",
    "voc_size_en = len(word_list_en)\n",
    "print(\" 句子数量：\", len(sentences)) # 打印句子数\n",
    "print(\" 中文词汇表大小：\", voc_size_cn) # 打印中文词汇表大小\n",
    "print(\" 英文词汇表大小：\", voc_size_en) # 打印英文词汇表大小\n",
    "print(\" 中文词汇到索引的字典：\", word2idx_cn) # 打印中文词汇到索引的字典\n",
    "print(\" 英文词汇到索引的字典：\", word2idx_en) # 打印英文词汇到索引的字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "977bf0e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 原始句子： ['深度学习 改变 世界', '<sos> DL changed the world', 'DL changed the world <eos>']\n",
      " 编码器输入张量的形状： torch.Size([1, 3])\n",
      " 解码器输入张量的形状： torch.Size([1, 5])\n",
      " 目标张量的形状： torch.Size([1, 5])\n",
      " 编码器输入张量： tensor([[11,  2, 12]])\n",
      " 解码器输入张量： tensor([[ 7, 17, 14,  5,  2]])\n",
      " 目标张量： tensor([[17, 14,  5,  2, 12]])\n"
     ]
    }
   ],
   "source": [
    "import numpy as np # 导入 numpy\n",
    "import torch # 导入 torch\n",
    "import random # 导入 random 库\n",
    "# 定义一个函数，随机选择一个句子和词汇表生成输入、输出和目标数据\n",
    "def make_data(sentences):\n",
    "    # 随机选择一个句子进行训练\n",
    "    random_sentence = random.choice(sentences)\n",
    "    # 将输入句子中的单词转换为对应的索引\n",
    "    encoder_input = np.array([[word2idx_cn[n] for n in random_sentence[0].split()]])\n",
    "    # 将输出句子中的单词转换为对应的索引\n",
    "    decoder_input = np.array([[word2idx_en[n] for n in random_sentence[1].split()]])\n",
    "    # 将目标句子中的单词转换为对应的索引\n",
    "    target = np.array([[word2idx_en[n] for n in random_sentence[2].split()]])\n",
    "    # 将输入、输出和目标批次转换为 LongTensor\n",
    "    encoder_input = torch.LongTensor(encoder_input)\n",
    "    decoder_input = torch.LongTensor(decoder_input)\n",
    "    target = torch.LongTensor(target)\n",
    "    return encoder_input, decoder_input, target \n",
    "# 使用 make_data 函数生成输入、输出和目标张量\n",
    "encoder_input, decoder_input, target = make_data(sentences)\n",
    "for s in sentences: # 获取原始句子\n",
    "    if all([word2idx_cn[w] in encoder_input[0] for w in s[0].split()]):\n",
    "        original_sentence = s\n",
    "        break\n",
    "print(\" 原始句子：\", original_sentence) # 打印原始句子\n",
    "print(\" 编码器输入张量的形状：\", encoder_input.shape)  # 打印输入张量形状\n",
    "print(\" 解码器输入张量的形状：\", decoder_input.shape) # 打印输出张量形状\n",
    "print(\" 目标张量的形状：\", target.shape) # 打印目标张量形状\n",
    "print(\" 编码器输入张量：\", encoder_input) # 打印输入张量\n",
    "print(\" 解码器输入张量：\", decoder_input) # 打印输出张量\n",
    "print(\" 目标张量：\", target) # 打印目标张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d44611b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义 Attention 类\n",
    "import torch.nn as nn # 导入 torch.nn 库\n",
    "class Attention(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Attention, self).__init__()\n",
    "    def forward(self, decoder_context, encoder_context):\n",
    "        # 计算 decoder_context 和 encoder_context 的点积，得到注意力分数\n",
    "        scores = torch.matmul(decoder_context, encoder_context.transpose(-2, -1))\n",
    "        # 归一化分数\n",
    "        attn_weights = nn.functional.softmax(scores, dim=-1)\n",
    "        # 将注意力权重乘以 encoder_context，得到加权的上下文向量\n",
    "        context = torch.matmul(attn_weights, encoder_context)\n",
    "        return context, attn_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "192a6f29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 编码器结构： Encoder(\n",
      "  (embedding): Embedding(18, 128)\n",
      "  (rnn): RNN(128, 128, batch_first=True)\n",
      ")\n",
      " 解码器结构： DecoderWithAttention(\n",
      "  (embedding): Embedding(20, 128)\n",
      "  (rnn): RNN(128, 128, batch_first=True)\n",
      "  (attention): Attention()\n",
      "  (out): Linear(in_features=256, out_features=20, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn # 导入 torch.nn 库\n",
    "# 定义编码器类\n",
    "class Encoder(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(Encoder, self).__init__()       \n",
    "        self.hidden_size = hidden_size # 设置隐藏层大小       \n",
    "        self.embedding = nn.Embedding(input_size, hidden_size) # 创建词嵌入层       \n",
    "        self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True) # 创建 RNN 层    \n",
    "    def forward(self, inputs, hidden): # 前向传播函数\n",
    "        embedded = self.embedding(inputs) # 将输入转换为嵌入向量       \n",
    "        output, hidden = self.rnn(embedded, hidden) # 将嵌入向量输入 RNN 层并获取输出\n",
    "        return output, hidden\n",
    "# 定义解码器类\n",
    "class DecoderWithAttention(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size):\n",
    "        super(DecoderWithAttention, self).__init__()\n",
    "        self.hidden_size = hidden_size # 设置隐藏层大小\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size) # 创建词嵌入层\n",
    "        self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True) # 创建 RNN 层\n",
    "        self.attention = Attention()  # 创建注意力层\n",
    "        self.out = nn.Linear(2 * hidden_size, output_size)  # 修改线性输出层，考虑隐藏状态和上下文向量\n",
    "    def forward(self, dec_input, hidden, enc_output):\n",
    "        embedded = self.embedding(dec_input)  # 将输入转换为嵌入向量\n",
    "        rnn_output, hidden = self.rnn(embedded, hidden)  # 将嵌入向量输入 RNN 层并获取输出 \n",
    "        context, attn_weights = self.attention(rnn_output, enc_output)  # 计算注意力上下文向量\n",
    "        dec_output = torch.cat((rnn_output, context), dim=-1)  # 将上下文向量与解码器的输出拼接\n",
    "        dec_output = self.out(dec_output)  # 使用线性层生成最终输出\n",
    "        return dec_output, hidden, attn_weights\n",
    "n_hidden = 128 # 设置隐藏层数量\n",
    "# 创建编码器和解码器\n",
    "encoder = Encoder(voc_size_cn, n_hidden)\n",
    "decoder = DecoderWithAttention(n_hidden, voc_size_en)\n",
    "print(' 编码器结构：', encoder)  # 打印编码器的结构\n",
    "print(' 解码器结构：', decoder)  # 打印解码器的结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "60b14dc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S2S 模型结构： Seq2Seq(\n",
      "  (encoder): Encoder(\n",
      "    (embedding): Embedding(18, 128)\n",
      "    (rnn): RNN(128, 128, batch_first=True)\n",
      "  )\n",
      "  (decoder): DecoderWithAttention(\n",
      "    (embedding): Embedding(20, 128)\n",
      "    (rnn): RNN(128, 128, batch_first=True)\n",
      "    (attention): Attention()\n",
      "    (out): Linear(in_features=256, out_features=20, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# 定义 Seq2Seq 类\n",
    "class Seq2Seq(nn.Module):\n",
    "    def __init__(self, encoder, decoder):\n",
    "        super(Seq2Seq, self).__init__()\n",
    "        # 初始化编码器和解码器\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder    \n",
    "    def forward(self, encoder_input, hidden, decoder_input): \n",
    "        # 将输入序列通过编码器并获取输出和隐藏状态\n",
    "        encoder_output, encoder_hidden = self.encoder(encoder_input, hidden)\n",
    "        # 将编码器的隐藏状态传递给解码器作为初始隐藏状态\n",
    "        decoder_hidden = encoder_hidden\n",
    "        # 将目标序列通过解码器并获取输出 -  此处更新解码器调用\n",
    "        decoder_output, _, attn_weights = self.decoder(decoder_input, decoder_hidden, encoder_output) \n",
    "        return decoder_output, attn_weights\n",
    "# 创建 Seq2Seq 模型\n",
    "model = Seq2Seq(encoder, decoder)\n",
    "print('S2S 模型结构：', model)  # 打印模型的结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c8bedb08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0040 cost = 0.189726\n",
      "Epoch: 0080 cost = 0.020979\n",
      "Epoch: 0120 cost = 0.037392\n",
      "Epoch: 0160 cost = 0.016500\n",
      "Epoch: 0200 cost = 0.011297\n",
      "Epoch: 0240 cost = 0.008235\n",
      "Epoch: 0280 cost = 0.006975\n",
      "Epoch: 0320 cost = 0.005550\n",
      "Epoch: 0360 cost = 0.002908\n",
      "Epoch: 0400 cost = 0.004215\n"
     ]
    }
   ],
   "source": [
    "# 定义训练函数\n",
    "def train_seq2seq(model, criterion, optimizer, epochs):\n",
    "    for epoch in range(epochs):\n",
    "       encoder_input, decoder_input, target = make_data(sentences) # 训练数据的创建\n",
    "       hidden = torch.zeros(1, encoder_input.size(0), n_hidden) # 初始化隐藏状态      \n",
    "       optimizer.zero_grad()# 梯度清零        \n",
    "       output, _ = model(encoder_input, hidden, decoder_input) # 获取模型输出         \n",
    "       loss = criterion(output.view(-1, voc_size_en), target.view(-1)) # 计算损失        \n",
    "       if (epoch + 1) % 40 == 0: # 打印损失\n",
    "          print(f\"Epoch: {epoch + 1:04d} cost = {loss:.6f}\")         \n",
    "       loss.backward()# 反向传播        \n",
    "       optimizer.step()# 更新参数      \n",
    "# 训练模型\n",
    "epochs = 400 # 训练轮次\n",
    "criterion = nn.CrossEntropyLoss() # 损失函数\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 优化器\n",
    "train_seq2seq(model, criterion, optimizer, epochs) # 调用函数训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d4f34f51",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # 导入 matplotlib\n",
    "import seaborn as sns # 导入 seaborn\n",
    "plt.rcParams[\"font.family\"]=['SimHei'] # 用来设定字体样式\n",
    "plt.rcParams['font.sans-serif']=['SimHei'] # 用来设定无衬线字体样式\n",
    "plt.rcParams['axes.unicode_minus']=False #  用 来 正 常 显 示 负 号 \n",
    "def  visualize_attention(source_sentence, predicted_sentence, attn_weights):    \n",
    "    plt.figure(figsize=(10, 10)) # 画布\n",
    "    ax = sns.heatmap(attn_weights, annot=True, cbar=False, \n",
    "                     xticklabels=source_sentence.split(), \n",
    "                     yticklabels=predicted_sentence, cmap=\"Greens\") # 热力图\n",
    "    plt.xlabel(\" 源序列 \") \n",
    "    plt.ylabel(\" 目标序列 \")\n",
    "    plt.show() # 显示图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2a5e9871",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "咖哥 喜欢 小冰 -> ['KaGe', '<eos>', 'KaGe']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "自然 语言 处理 很 强大 -> ['NLP', 'is', '<eos>', '<eos>', '<eos>']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义测试函数\n",
    "def test_seq2seq(model, source_sentence):\n",
    "    # 将输入的句子转换为索引\n",
    "    encoder_input = np.array([[word2idx_cn[n] for n in source_sentence.split()]])\n",
    "    # 构建输出的句子的索引，以 '<sos>' 开始，后面跟 '<eos>'，长度与输入句子相同\n",
    "    decoder_input = np.array([word2idx_en['<sos>']] + [word2idx_en['<eos>']]*(len(encoder_input[0])-1))\n",
    "    # 转换为 LongTensor 类型\n",
    "    encoder_input = torch.LongTensor(encoder_input)\n",
    "    decoder_input = torch.LongTensor(decoder_input).unsqueeze(0) # 增加一维    \n",
    "    hidden = torch.zeros(1, encoder_input.size(0), n_hidden) # 初始化隐藏状态    \n",
    "    # 获取模型输出和注意力权重\n",
    "    predict, attn_weights = model(encoder_input, hidden, decoder_input)    \n",
    "    predict = predict.data.max(2, keepdim=True)[1] # 获取概率最大的索引\n",
    "    # 打印输入的句子和预测的句子\n",
    "    print(source_sentence, '->', [idx2word_en[n.item()] for n in predict.squeeze()])\n",
    "    # 可视化注意力权重\n",
    "    attn_weights = attn_weights.squeeze(0).cpu().detach().numpy()\n",
    "    visualize_attention(source_sentence, [idx2word_en[n.item()] for n in predict.squeeze()], attn_weights)    \n",
    "# 测试模型\n",
    "test_seq2seq(model, '咖哥 喜欢 小冰')  \n",
    "test_seq2seq(model, '自然 语言 处理 很 强大')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd98da8a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
